home *** CD-ROM | disk | FTP | other *** search
/ Developer CD Series 1997 July: Mac OS SDK / Dev.CD Jul 97 SDK1.toast / Development Kits (Disc 1) / Interfaces&Libraries / Interfaces / PInterfaces / OCEMessaging.p < prev    next >
Encoding:
Text File  |  1995-07-06  |  28.6 KB  |  1,162 lines  |  [TEXT/MPS ]
  1. {
  2.      File:        OCEMessaging.p
  3.  
  4.      Contains:    Apple Open Collaboration Environment Messaging Interfaces.
  5.  
  6.      Version:    Technology:    AOCE Toolbox 1.02
  7.                  Package:    Universal Interfaces 2.1 in “MPW Latest” on ETO #18
  8.  
  9.      Copyright:    © 1984-1995 by Apple Computer, Inc.
  10.                  All rights reserved.
  11.  
  12.      Bugs?:        If you find a problem with this file, use the Apple Bug Reporter
  13.                  stack.  Include the file and version information (from above)
  14.                  in the problem description and send to:
  15.                      Internet:    apple.bugs@applelink.apple.com
  16.                      AppleLink:    APPLE.BUGS
  17.  
  18. }
  19.  
  20. {$IFC UNDEFINED UsingIncludes}
  21. {$SETC UsingIncludes := 0}
  22. {$ENDC}
  23.  
  24. {$IFC NOT UsingIncludes}
  25.  UNIT OCEMessaging;
  26.  INTERFACE
  27. {$ENDC}
  28.  
  29. {$IFC UNDEFINED __OCEMESSAGING__}
  30. {$SETC __OCEMESSAGING__ := 1}
  31.  
  32. {$I+}
  33. {$SETC OCEMessagingIncludes := UsingIncludes}
  34. {$SETC UsingIncludes := 1}
  35.  
  36.  
  37. {$IFC UNDEFINED __APPLEEVENTS__}
  38. {$I AppleEvents.p}
  39. {$ENDC}
  40. {    Errors.p                                                    }
  41. {        ConditionalMacros.p                                        }
  42. {    Types.p                                                        }
  43. {    Memory.p                                                    }
  44. {        MixedMode.p                                                }
  45. {    OSUtils.p                                                    }
  46. {    Events.p                                                    }
  47. {        Quickdraw.p                                                }
  48. {            QuickdrawText.p                                        }
  49. {    EPPC.p                                                        }
  50. {        AppleTalk.p                                                }
  51. {        Files.p                                                    }
  52. {            Finder.p                                            }
  53. {        PPCToolbox.p                                            }
  54. {        Processes.p                                                }
  55. {    Notification.p                                                }
  56.  
  57. {$IFC UNDEFINED __FILES__}
  58. {$I Files.p}
  59. {$ENDC}
  60.  
  61. {$IFC UNDEFINED __TYPES__}
  62. {$I Types.p}
  63. {$ENDC}
  64.  
  65. {$IFC UNDEFINED __DIGITALSIGNATURE__}
  66. {$I DigitalSignature.p}
  67. {$ENDC}
  68.  
  69. {$IFC UNDEFINED __OCE__}
  70. {$I OCE.p}
  71. {$ENDC}
  72. {    Aliases.p                                                    }
  73. {    Script.p                                                    }
  74. {        IntlResources.p                                            }
  75.  
  76. {$IFC UNDEFINED __OCEAUTHDIR__}
  77. {$I OCEAuthDir.p}
  78. {$ENDC}
  79.  
  80. {$PUSH}
  81. {$ALIGN MAC68K}
  82. {$LibExport+}
  83. {****************************************************************************}
  84. { Definitions common to OCEMessaging and to OCEMail. These relate to addressing,
  85. message ids and priorities, etc. }
  86. { Values of IPMPriority }
  87.  
  88. CONST
  89.     kIPMAnyPriority                = 0;                            { FOR FILTER ONLY }
  90.     kIPMNormalPriority            = 1;
  91.     kIPMLowPriority                = 2;
  92.     kIPMHighPriority            = 3;
  93.  
  94.     
  95. TYPE
  96.     IPMPriority = SignedByte;
  97.  
  98. { Values of IPMAccessMode }
  99.  
  100. CONST
  101.     kIPMAtMark                    = 0;
  102.     kIPMFromStart                = 1;
  103.     kIPMFromLEOM                = 2;
  104.     kIPMFromMark                = 3;
  105.  
  106.     
  107. TYPE
  108.     IPMAccessMode = INTEGER;
  109.  
  110.  
  111. CONST
  112.     kIPMUpdateMsgBit            = 4;
  113.     kIPMNewMsgBit                = 5;
  114.     kIPMDeleteMsgBit            = 6;
  115.  
  116. { Values of IPMNotificationType }
  117.     kIPMUpdateMsgMask            = 1 * (2**(kIPMUpdateMsgBit));
  118.     kIPMNewMsgMask                = 1 * (2**(kIPMNewMsgBit));
  119.     kIPMDeleteMsgMask            = 1 * (2**(kIPMDeleteMsgBit));
  120.  
  121.     
  122. TYPE
  123.     IPMNotificationType = SignedByte;
  124.  
  125. { Values of IPMSenderTag }
  126.  
  127. CONST
  128.     kIPMSenderRStringTag        = 0;
  129.     kIPMSenderRecordIDTag        = 1;
  130.  
  131.     
  132. TYPE
  133.     IPMSenderTag = INTEGER;
  134.  
  135.  
  136. CONST
  137.     kIPMFromDistListBit            = 0;
  138.     kIPMDummyRecBit                = 1;
  139.     kIPMFeedbackRecBit            = 2;                            { should be redirected to feedback queue }
  140.     kIPMReporterRecBit            = 3;                            { should be redirected to reporter original queue }
  141.     kIPMBCCRecBit                = 4;                            { this recipient is blind to all recipients of message }
  142.  
  143. { Values of OCERecipientOffsetFlags }
  144.     kIPMFromDistListMask        = 1 * (2**(kIPMFromDistListBit));
  145.     kIPMDummyRecMask            = 1 * (2**(kIPMDummyRecBit));
  146.     kIPMFeedbackRecMask            = 1 * (2**(kIPMFeedbackRecBit));
  147.     kIPMReporterRecMask            = 1 * (2**(kIPMReporterRecBit));
  148.     kIPMBCCRecMask                = 1 * (2**(kIPMBCCRecBit));
  149.  
  150.     
  151. TYPE
  152.     OCERecipientOffsetFlags = SignedByte;
  153.  
  154.     OCECreatorType = RECORD
  155.         msgCreator:                OSType;
  156.         msgType:                OSType;
  157.     END;
  158.  
  159.  
  160. CONST
  161.     kIPMTypeWildCard            = 'ipmw';
  162.     kIPMFamilyUnspecified        = 0;
  163.     kIPMFamilyWildCard            = $3F3F3F3F;                    { '??^ 
  164.  
  165.     * well known signature }
  166.     kIPMSignature                = 'ipms';                        { base type 
  167.  
  168.     * well known message types }
  169.     kIPMReportNotify            = 'rptn';                        { routing feedback
  170.  
  171.     * well known message block types }
  172.     kIPMEnclosedMsgType            = 'emsg';                        { enclosed (nested) message }
  173.     kIPMReportInfo                = 'rpti';                        { recipient information }
  174.     kIPMDigitalSignature        = 'dsig';
  175.  
  176. { Values of IPMMsgFormat }
  177.     kIPMOSFormatType            = 1;
  178.     kIPMStringFormatType        = 2;
  179.  
  180.     
  181. TYPE
  182.     IPMMsgFormat = INTEGER;
  183.  
  184.     IPMStringMsgType = Str32;
  185.  
  186.     TheType = RECORD
  187.         CASE INTEGER OF
  188.         0: (
  189.             msgOSType:                    OCECreatorType;
  190.            );
  191.         1: (
  192.             msgStrType:                    IPMStringMsgType;
  193.            );
  194.     END;
  195.  
  196.     IPMMsgType = RECORD
  197.         format:                    IPMMsgFormat;                            { IPMMsgFormat}
  198.         theType:                TheType;
  199.     END;
  200.  
  201. {
  202. Following are the known extension values for IPM addresses handled by Apple.
  203. We define the definition of the entn extension below.
  204. }
  205.  
  206. CONST
  207.     kOCEalanXtn                    = 'alan';
  208.     kOCEentnXtn                    = 'entn';                        { entn = entity name (aka DSSpec) }
  209.     kOCEaphnXtn                    = 'aphn';
  210.  
  211. {
  212. Following are the specific definitions for the extension for the standard
  213. OCEMail 'entn' addresses.  [Note, the actual extension is formatted as in
  214. IPMEntityNameExtension.]
  215. }
  216. { entn extension forms }
  217.     kOCEAddrXtn                    = 'addr';
  218.     kOCEQnamXtn                    = 'qnam';
  219.     kOCEAttrXtn                    = 'attr';                        { an attribute specification }
  220.     kOCESpAtXtn                    = 'spat';
  221.  
  222. {
  223. Following are the specific definitions for standard
  224. OCEMail 'aphn' extension value.  
  225.  
  226. All RStrings here are packed (e.g. truncated to length) and even padded (e.g.
  227. if length odd, then a pad byte (zero) should be introduced before the next field).
  228.  
  229. The extension value is in the packed form of the following structure:
  230.     RString        phoneNumber;
  231.     RString        modemType;
  232.     Str32        queueuName;
  233.  
  234. The body of phoneNumber compound RString is in the packed form of the following structure:
  235.     short         subType;
  236.     RString     countryCode;                // used when subType == kOCEUseHandyDial
  237.     RString        areaCode;                    // used when subType == kOCEUseHandyDial
  238.     RString        phone;                        // used when subType == kOCEUseHandyDial
  239.     RString        postFix;                    // used when subType == kOCEUseHandyDial
  240.     RString        nonHandyDialString;            // used when subType == kOCEDontUseHandyDial
  241. }
  242. { phoneNumber sub type constants }
  243.     kOCEUseHandyDial            = 1;
  244.     kOCEDontUseHandyDial        = 2;
  245.  
  246. { FORMAT OF A PACKED FORM RECIPIENT }
  247.  
  248. TYPE
  249.     ProtoOCEPackedRecipient = RECORD
  250.         dataLength:                INTEGER;
  251.     END;
  252.  
  253.  
  254. CONST
  255.     kOCEPackedRecipientMaxBytes    = 0+(4096 - sizeof(ProtoOCEPackedRecipient));
  256.  
  257.  
  258. TYPE
  259.     OCEPackedRecipient = RECORD
  260.         dataLength:                INTEGER;
  261.         data:                    ARRAY [0..kOCEPackedRecipientMaxBytes-1] OF SInt8; (* Byte *)
  262.     END;
  263.  
  264.     IPMEntnQueueExtension = RECORD
  265.         queueName:                Str32;
  266.     END;
  267.  
  268. { kOCEAttrXtn }
  269.     IPMEntnAttributeExtension = RECORD
  270.         attributeName:            AttributeType;
  271.     END;
  272.  
  273. { kOCESpAtXtn }
  274.     IPMEntnSpecificAttributeExtension = RECORD
  275.         attributeCreationID:    AttributeCreationID;
  276.         attributeName:            AttributeType;
  277.     END;
  278.  
  279. { All IPM entn extensions fit within the following }
  280.     IPMEntityNameExtension = RECORD
  281.         subExtensionType:        OSType;
  282.         CASE INTEGER OF
  283.         0: (
  284.             specificAttribute:            IPMEntnSpecificAttributeExtension;
  285.            );
  286.         1: (
  287.             attribute:                    IPMEntnAttributeExtension;
  288.            );
  289.         2: (
  290.             queue:                        IPMEntnQueueExtension;
  291.            );
  292.  
  293.     END;
  294.  
  295. { addresses with kIPMNBPXtn should specify this nbp type }
  296.     IPMMsgID = RECORD
  297.         id:                        ARRAY [0..3] OF LONGINT;
  298.     END;
  299.  
  300. { Values of IPMHeaderSelector }
  301.  
  302. CONST
  303.     kIPMTOC                        = 0;
  304.     kIPMSender                    = 1;
  305.     kIPMProcessHint                = 2;
  306.     kIPMMessageTitle            = 3;
  307.     kIPMMessageType                = 4;
  308.     kIPMFixedInfo                = 7;
  309.  
  310.     
  311. TYPE
  312.     IPMHeaderSelector = SInt8;
  313.  
  314.     TheSender = RECORD
  315.         CASE INTEGER OF
  316.         0: (
  317.             rString:                    RString;
  318.            );
  319.         1: (
  320.             rid:                        PackedRecordID;
  321.            );
  322.     END;
  323.  
  324.     IPMSender = RECORD
  325.         sendTag:                IPMSenderTag;
  326.         theSender:                TheSender;
  327.     END;
  328.  
  329. {****************************************************************************}
  330. { Definitions specific to OCEMessaging }
  331.     IPMContextRef = LONGINT;
  332.  
  333.     IPMQueueRef = LONGINT;
  334.  
  335.     IPMMsgRef = LONGINT;
  336.  
  337.     IPMSeqNum = LONGINT;
  338.  
  339.     IPMProcHint = Str32;
  340.  
  341.     IPMQueueName = Str32;
  342.  
  343.     IPMNoteProcPtr = ProcPtr;  { PROCEDURE IPMNote(queue: IPMQueueRef; seqNum: IPMSeqNum; notificationType: ByteParameter; userData: LONGINT); }
  344.     IPMNoteUPP = UniversalProcPtr;
  345.  
  346. CONST
  347.     uppIPMNoteProcInfo = $000037C0; { PROCEDURE (4 byte param, 4 byte param, 1 byte param, 4 byte param); }
  348.  
  349. FUNCTION NewIPMNoteProc(userRoutine: IPMNoteProcPtr): IPMNoteUPP;
  350.     {$IFC NOT GENERATINGCFM }
  351.     INLINE $2E9F;
  352.     {$ENDC}
  353.  
  354. PROCEDURE CallIPMNoteProc(queue: IPMQueueRef; seqNum: IPMSeqNum; notificationType: ByteParameter; userData: LONGINT; userRoutine: IPMNoteUPP);
  355.     {$IFC NOT GENERATINGCFM}
  356.     INLINE $205F, $4E90;
  357.     {$ENDC}
  358.  
  359. TYPE
  360.     IPMFixedHdrInfo = RECORD
  361.         version:                INTEGER;
  362.         authenticated:            BOOLEAN;
  363.         signatureEnclosed:        BOOLEAN;                                {  digital signature enclosed }
  364.         msgSize:                LONGINT;
  365.         notification:            IPMNotificationType;
  366.         priority:                IPMPriority;
  367.         blockCount:                INTEGER;
  368.         originalRcptCount:        INTEGER;                                {        original number of recipients }
  369.         refCon:                    LONGINT;                                {        Client defined data }
  370.         reserved:                INTEGER;
  371.         creationTime:            UTCTime;                                {        Time when it was created }
  372.         msgID:                    IPMMsgID;
  373.         family:                    OSType;                                    { family this msg belongs (e.g. mail) }
  374.     END;
  375.  
  376.  
  377. CONST
  378.     kIPMDeliveryNotificationBit    = 0;
  379.     kIPMNonDeliveryNotificationBit = 1;
  380.     kIPMEncloseOriginalBit        = 2;
  381.     kIPMSummaryReportBit        = 3;
  382. { modify enclose original to only on error }
  383.     kIPMOriginalOnlyOnErrorBit    = 4;
  384.  
  385.     kIPMNoNotificationMask        = $00;
  386.     kIPMDeliveryNotificationMask = 1 * (2**(kIPMDeliveryNotificationBit));
  387.     kIPMNonDeliveryNotificationMask = 1 * (2**(kIPMNonDeliveryNotificationBit));
  388.     kIPMDontEncloseOriginalMask    = $00;
  389.     kIPMEncloseOriginalMask        = 1 * (2**(kIPMEncloseOriginalBit));
  390.     kIPMImmediateReportMask        = $00;
  391.     kIPMSummaryReportMask        = 1 * (2**(kIPMSummaryReportBit));
  392.     kIPMOriginalOnlyOnErrorMask    = 1 * (2**(kIPMOriginalOnlyOnErrorBit));
  393.     kIPMEncloseOriginalOnErrorMask = 0+(kIPMOriginalOnlyOnErrorMask + kIPMEncloseOriginalMask);
  394.  
  395. { standard Non delivery codes }
  396.     kIPMNoSuchRecipient            = $0001;
  397.     kIPMRecipientMalformed        = $0002;
  398.     kIPMRecipientAmbiguous        = $0003;
  399.     kIPMRecipientAccessDenied    = $0004;
  400.     kIPMGroupExpansionProblem    = $0005;
  401.     kIPMMsgUnreadable            = $0006;
  402.     kIPMMsgExpired                = $0007;
  403.     kIPMMsgNoTranslatableContent = $0008;
  404.     kIPMRecipientReqStdCont        = $0009;
  405.     kIPMRecipientReqSnapShot    = $000A;
  406.     kIPMNoTransferDiskFull        = $000B;
  407.     kIPMNoTransferMsgRejectedbyDest = $000C;
  408.     kIPMNoTransferMsgTooLarge    = $000D;
  409.  
  410. {***********************************************************************}
  411. {
  412. This is the structure that will be returned by enumerate and getmsginfo
  413. This definition is just to give you a template, the position of msgType
  414. is variable since this is a packed structure.  procHint and msgType are
  415. packed and even length padded.
  416.  
  417. * master message info }
  418.  
  419. TYPE
  420.     IPMMsgInfo = RECORD
  421.         sequenceNum:            IPMSeqNum;
  422.         userData:                LONGINT;
  423.         respIndex:                INTEGER;
  424.         padByte:                SInt8;
  425.         priority:                IPMPriority;
  426.         msgSize:                LONGINT;
  427.         originalRcptCount:        INTEGER;
  428.         reserved:                INTEGER;
  429.         creationTime:            UTCTime;
  430.         msgID:                    IPMMsgID;
  431.         family:                    OSType;                                    { family this msg belongs (e.g. mail) }
  432.         procHint:                IPMProcHint;
  433.         filler2:                SInt8;
  434.         msgType:                IPMMsgType;
  435.     END;
  436.  
  437.     IPMBlockType = OCECreatorType;
  438.  
  439.     IPMTOC = RECORD
  440.         blockType:                IPMBlockType;
  441.         blockOffset:            LONGINT;
  442.         blockSize:                LONGINT;
  443.         blockRefCon:            LONGINT;
  444.     END;
  445.  
  446. {
  447. The following structure is just to describe the layout of the SingleFilter.
  448. Each field should be packed and word aligned when passed to the IPM ToolBox.
  449. }
  450.     IPMSingleFilter = RECORD
  451.         priority:                IPMPriority;
  452.         padByte:                SInt8;
  453.         family:                    OSType;                                    { family this msg belongs (e.g. mail), '??^ for all }
  454.         script:                    ScriptCode;                                { Language Identifier }
  455.         hint:                    IPMProcHint;
  456.         filler2:                SInt8;
  457.         msgType:                IPMMsgType;
  458.     END;
  459.  
  460.     IPMFilter = RECORD
  461.         count:                    INTEGER;
  462.         sFilters:                ARRAY [0..0] OF IPMSingleFilter;
  463.     END;
  464.  
  465. {************************************************************************
  466. Following structures define the “start” of a recipient report block and the
  467. elements of the array respectively.
  468. }
  469.     IPMReportBlockHeader = RECORD
  470.         msgID:                    IPMMsgID;                                { message id of the original }
  471.         creationTime:            UTCTime;                                { creation time of the report }
  472.     END;
  473.  
  474.     OCERecipientReport = RECORD
  475.         rcptIndex:                INTEGER;                                { index of recipient in original message }
  476.         result:                    OSErr;                                    { result of sending letter to this recipient}
  477.     END;
  478.  
  479. {***********************************************************************}
  480.     IPMParamBlockPtr = ^IPMParamBlock;
  481.  
  482.     IPMIOCompletionProcPtr = ProcPtr;  { PROCEDURE IPMIOCompletion(paramBlock: IPMParamBlockPtr); }
  483.     IPMIOCompletionUPP = UniversalProcPtr;
  484.  
  485.     IPMOpenContextPB = RECORD
  486.         qLink:                    Ptr;
  487.         reservedH1:                LONGINT;
  488.         reservedH2:                LONGINT;
  489.         ioCompletion:            IPMIOCompletionUPP;
  490.         ioResult:                OSErr;
  491.         saveA5:                    LONGINT;
  492.         reqCode:                INTEGER;
  493.         contextRef:                IPMContextRef;                            { <--  Context reference to be used in further calls}
  494.     END;
  495.  
  496.     IPMCloseContextPB = IPMOpenContextPB;
  497.  
  498.     IPMCreateQueuePB = RECORD
  499.         qLink:                    Ptr;
  500.         reservedH1:                LONGINT;
  501.         reservedH2:                LONGINT;
  502.         ioCompletion:            IPMIOCompletionUPP;
  503.         ioResult:                OSErr;
  504.         saveA5:                    LONGINT;
  505.         reqCode:                INTEGER;
  506.         filler1:                LONGINT;
  507.         queue:                    ^OCERecipient;
  508.         identity:                AuthIdentity;                            { used only if queue is remote }
  509.         owner:                    ^PackedRecordID;                        { used only if queue is remote }
  510.     END;
  511.  
  512. { For createqueue and deletequeue only queue and identity are used }
  513.     IPMDeleteQueuePB = IPMCreateQueuePB;
  514.  
  515.     IPMOpenQueuePB = RECORD
  516.         qLink:                    Ptr;
  517.         reservedH1:                LONGINT;
  518.         reservedH2:                LONGINT;
  519.         ioCompletion:            IPMIOCompletionUPP;
  520.         ioResult:                OSErr;
  521.         saveA5:                    LONGINT;
  522.         reqCode:                INTEGER;
  523.         contextRef:                IPMContextRef;
  524.         queue:                    ^OCERecipient;
  525.         identity:                AuthIdentity;
  526.         filter:                    ^IPMFilter;
  527.         newQueueRef:            IPMQueueRef;
  528.         notificationProc:        IPMNoteUPP;
  529.         userData:                LONGINT;
  530.         noteType:                IPMNotificationType;
  531.         padByte:                SInt8; (* Byte *)
  532.         reserved:                LONGINT;
  533.         reserved2:                LONGINT;
  534.     END;
  535.  
  536.     IPMCloseQueuePB = RECORD
  537.         qLink:                    Ptr;
  538.         reservedH1:                LONGINT;
  539.         reservedH2:                LONGINT;
  540.         ioCompletion:            IPMIOCompletionUPP;
  541.         ioResult:                OSErr;
  542.         saveA5:                    LONGINT;
  543.         reqCode:                INTEGER;
  544.         queueRef:                IPMQueueRef;
  545.     END;
  546.  
  547.     IPMEnumerateQueuePB = RECORD
  548.         qLink:                    Ptr;
  549.         reservedH1:                LONGINT;
  550.         reservedH2:                LONGINT;
  551.         ioCompletion:            IPMIOCompletionUPP;
  552.         ioResult:                OSErr;
  553.         saveA5:                    LONGINT;
  554.         reqCode:                INTEGER;
  555.         queueRef:                IPMQueueRef;
  556.         startSeqNum:            IPMSeqNum;
  557.         getProcHint:            BOOLEAN;
  558.         getMsgType:                BOOLEAN;
  559.         filler:                    INTEGER;
  560.         filter:                    ^IPMFilter;
  561.         numToGet:                INTEGER;
  562.         numGotten:                INTEGER;
  563.         enumCount:                LONGINT;
  564.         enumBuffer:                Ptr;                                    { will be packed array of IPMMsgInfo }
  565.         actEnumCount:            LONGINT;
  566.     END;
  567.  
  568.     IPMChangeQueueFilterPB = IPMEnumerateQueuePB;
  569.  
  570.     IPMDeleteMsgRangePB = RECORD
  571.         qLink:                    Ptr;
  572.         reservedH1:                LONGINT;
  573.         reservedH2:                LONGINT;
  574.         ioCompletion:            IPMIOCompletionUPP;
  575.         ioResult:                OSErr;
  576.         saveA5:                    LONGINT;
  577.         reqCode:                INTEGER;
  578.         queueRef:                IPMQueueRef;
  579.         startSeqNum:            IPMSeqNum;
  580.         endSeqNum:                IPMSeqNum;
  581.         lastSeqNum:                IPMSeqNum;
  582.     END;
  583.  
  584.     IPMOpenMsgPB = RECORD
  585.         qLink:                    Ptr;
  586.         reservedH1:                LONGINT;
  587.         reservedH2:                LONGINT;
  588.         ioCompletion:            IPMIOCompletionUPP;
  589.         ioResult:                OSErr;
  590.         saveA5:                    LONGINT;
  591.         reqCode:                INTEGER;
  592.         queueRef:                IPMQueueRef;
  593.         sequenceNum:            IPMSeqNum;
  594.         newMsgRef:                IPMMsgRef;
  595.         actualSeqNum:            IPMSeqNum;
  596.         exactMatch:                BOOLEAN;
  597.         padByte:                SInt8; (* Byte *)
  598.         reserved:                LONGINT;
  599.     END;
  600.  
  601.     IPMOpenHFSMsgPB = RECORD
  602.         qLink:                    Ptr;
  603.         reservedH1:                LONGINT;
  604.         reservedH2:                LONGINT;
  605.         ioCompletion:            IPMIOCompletionUPP;
  606.         ioResult:                OSErr;
  607.         saveA5:                    LONGINT;
  608.         reqCode:                INTEGER;
  609.         hfsPath:                ^FSSpec;
  610.         filler:                    LONGINT;
  611.         newMsgRef:                IPMMsgRef;
  612.         filler2:                LONGINT;
  613.         filler3:                SInt8; (* Byte *)
  614.         filler4:                BOOLEAN;
  615.         reserved:                LONGINT;
  616.     END;
  617.  
  618.     IPMOpenBlockAsMsgPB = RECORD
  619.         qLink:                    Ptr;
  620.         reservedH1:                LONGINT;
  621.         reservedH2:                LONGINT;
  622.         ioCompletion:            IPMIOCompletionUPP;
  623.         ioResult:                OSErr;
  624.         saveA5:                    LONGINT;
  625.         reqCode:                INTEGER;
  626.         msgRef:                    IPMMsgRef;
  627.         filler:                    LONGINT;
  628.         newMsgRef:                IPMMsgRef;
  629.         filler2:                ARRAY [0..6] OF INTEGER;
  630.         blockIndex:                INTEGER;
  631.     END;
  632.  
  633.     IPMCloseMsgPB = RECORD
  634.         qLink:                    Ptr;
  635.         reservedH1:                LONGINT;
  636.         reservedH2:                LONGINT;
  637.         ioCompletion:            IPMIOCompletionUPP;
  638.         ioResult:                OSErr;
  639.         saveA5:                    LONGINT;
  640.         reqCode:                INTEGER;
  641.         msgRef:                    IPMMsgRef;
  642.         deleteMsg:                BOOLEAN;
  643.         filler1:                BOOLEAN;
  644.     END;
  645.  
  646.     IPMGetMsgInfoPB = RECORD
  647.         qLink:                    Ptr;
  648.         reservedH1:                LONGINT;
  649.         reservedH2:                LONGINT;
  650.         ioCompletion:            IPMIOCompletionUPP;
  651.         ioResult:                OSErr;
  652.         saveA5:                    LONGINT;
  653.         reqCode:                INTEGER;
  654.         msgRef:                    IPMMsgRef;
  655.         info:                    ^IPMMsgInfo;
  656.     END;
  657.  
  658.     IPMReadHeaderPB = RECORD
  659.         qLink:                    Ptr;
  660.         reservedH1:                LONGINT;
  661.         reservedH2:                LONGINT;
  662.         ioCompletion:            IPMIOCompletionUPP;
  663.         ioResult:                OSErr;
  664.         saveA5:                    LONGINT;
  665.         reqCode:                INTEGER;
  666.         msgRef:                    IPMMsgRef;
  667.         fieldSelector:            INTEGER;
  668.         offset:                    LONGINT;
  669.         count:                    LONGINT;
  670.         buffer:                    Ptr;
  671.         actualCount:            LONGINT;
  672.         filler:                    INTEGER;
  673.         remaining:                LONGINT;
  674.     END;
  675.  
  676.     IPMReadRecipientPB = RECORD
  677.         qLink:                    Ptr;
  678.         reservedH1:                LONGINT;
  679.         reservedH2:                LONGINT;
  680.         ioCompletion:            IPMIOCompletionUPP;
  681.         ioResult:                OSErr;
  682.         saveA5:                    LONGINT;
  683.         reqCode:                INTEGER;
  684.         msgRef:                    IPMMsgRef;
  685.         rcptIndex:                INTEGER;
  686.         offset:                    LONGINT;
  687.         count:                    LONGINT;
  688.         buffer:                    Ptr;
  689.         actualCount:            LONGINT;
  690.         reserved:                INTEGER;                                { must be zero }
  691.         remaining:                LONGINT;
  692.         originalIndex:            INTEGER;
  693.         recipientOffsetFlags:    OCERecipientOffsetFlags;
  694.         filler1:                BOOLEAN;
  695.     END;
  696.  
  697. {
  698. replyQueue works like recipient. [can no longer read it via ReadHeader]
  699. OriginalIndex is meaningless, rcptFlags are used seperately and there are
  700. currently none defined.
  701. }
  702.     IPMReadReplyQueuePB = IPMReadRecipientPB;
  703.  
  704.     IPMGetBlkIndexPB = RECORD
  705.         qLink:                    Ptr;
  706.         reservedH1:                LONGINT;
  707.         reservedH2:                LONGINT;
  708.         ioCompletion:            IPMIOCompletionUPP;
  709.         ioResult:                OSErr;
  710.         saveA5:                    LONGINT;
  711.         reqCode:                INTEGER;
  712.         msgRef:                    IPMMsgRef;
  713.         blockType:                IPMBlockType;
  714.         index:                    INTEGER;
  715.         startingFrom:            INTEGER;
  716.         actualBlockType:        IPMBlockType;
  717.         actualBlockIndex:        INTEGER;
  718.     END;
  719.  
  720.     IPMReadMsgPB = RECORD
  721.         qLink:                    Ptr;
  722.         reservedH1:                LONGINT;
  723.         reservedH2:                LONGINT;
  724.         ioCompletion:            IPMIOCompletionUPP;
  725.         ioResult:                OSErr;
  726.         saveA5:                    LONGINT;
  727.         reqCode:                INTEGER;
  728.         msgRef:                    IPMMsgRef;
  729.         mode:                    IPMAccessMode;
  730.         offset:                    LONGINT;
  731.         count:                    LONGINT;
  732.         buffer:                    Ptr;
  733.         actualCount:            LONGINT;
  734.         blockIndex:                INTEGER;
  735.         remaining:                LONGINT;
  736.     END;
  737.  
  738.     IPMVerifySignaturePB = RECORD
  739.         qLink:                    Ptr;
  740.         reservedH1:                LONGINT;
  741.         reservedH2:                LONGINT;
  742.         ioCompletion:            IPMIOCompletionUPP;
  743.         ioResult:                OSErr;
  744.         saveA5:                    LONGINT;
  745.         reqCode:                INTEGER;
  746.         msgRef:                    IPMMsgRef;
  747.         signatureContext:        SIGContextPtr;
  748.     END;
  749.  
  750.     IPMNewMsgPB = RECORD
  751.         qLink:                    Ptr;
  752.         reservedH1:                LONGINT;
  753.         reservedH2:                LONGINT;
  754.         ioCompletion:            IPMIOCompletionUPP;
  755.         ioResult:                OSErr;
  756.         saveA5:                    LONGINT;
  757.         reqCode:                INTEGER;
  758.         filler:                    LONGINT;
  759.         recipient:                ^OCERecipient;
  760.         replyQueue:                ^OCERecipient;
  761.         procHint:                StringPtr;
  762.         filler2:                INTEGER;
  763.         msgType:                ^IPMMsgType;
  764.         refCon:                    LONGINT;
  765.         newMsgRef:                IPMMsgRef;
  766.         filler3:                INTEGER;
  767.         filler4:                LONGINT;
  768.         identity:                AuthIdentity;
  769.         sender:                    ^IPMSender;
  770.         internalUse:            LONGINT;
  771.         internalUse2:            LONGINT;
  772.     END;
  773.  
  774.     IPMNewHFSMsgPB = RECORD
  775.         qLink:                    Ptr;
  776.         reservedH1:                LONGINT;
  777.         reservedH2:                LONGINT;
  778.         ioCompletion:            IPMIOCompletionUPP;
  779.         ioResult:                OSErr;
  780.         saveA5:                    LONGINT;
  781.         reqCode:                INTEGER;
  782.         hfsPath:                ^FSSpec;
  783.         recipient:                ^OCERecipient;
  784.         replyQueue:                ^OCERecipient;
  785.         procHint:                StringPtr;
  786.         filler2:                INTEGER;
  787.         msgType:                ^IPMMsgType;
  788.         refCon:                    LONGINT;
  789.         newMsgRef:                IPMMsgRef;
  790.         filler3:                INTEGER;
  791.         filler4:                LONGINT;
  792.         identity:                AuthIdentity;
  793.         sender:                    ^IPMSender;
  794.         internalUse:            LONGINT;
  795.         internalUse2:            LONGINT;
  796.     END;
  797.  
  798.     IPMNestMsgPB = RECORD
  799.         qLink:                    Ptr;
  800.         reservedH1:                LONGINT;
  801.         reservedH2:                LONGINT;
  802.         ioCompletion:            IPMIOCompletionUPP;
  803.         ioResult:                OSErr;
  804.         saveA5:                    LONGINT;
  805.         reqCode:                INTEGER;
  806.         msgRef:                    IPMMsgRef;
  807.         filler:                    ARRAY [0..8] OF INTEGER;
  808.         refCon:                    LONGINT;
  809.         msgToNest:                IPMMsgRef;
  810.         filler2:                INTEGER;
  811.         startingOffset:            LONGINT;
  812.     END;
  813.  
  814.     IPMNewNestedMsgBlockPB = RECORD
  815.         qLink:                    Ptr;
  816.         reservedH1:                LONGINT;
  817.         reservedH2:                LONGINT;
  818.         ioCompletion:            IPMIOCompletionUPP;
  819.         ioResult:                OSErr;
  820.         saveA5:                    LONGINT;
  821.         reqCode:                INTEGER;
  822.         msgRef:                    IPMMsgRef;
  823.         recipient:                ^OCERecipient;
  824.         replyQueue:                ^OCERecipient;
  825.         procHint:                StringPtr;
  826.         filler1:                INTEGER;
  827.         msgType:                ^IPMMsgType;
  828.         refCon:                    LONGINT;
  829.         newMsgRef:                IPMMsgRef;
  830.         filler2:                INTEGER;
  831.         startingOffset:            LONGINT;
  832.         identity:                AuthIdentity;
  833.         sender:                    ^IPMSender;
  834.         internalUse:            LONGINT;
  835.         internalUse2:            LONGINT;
  836.     END;
  837.  
  838.     IPMEndMsgPB = RECORD
  839.         qLink:                    Ptr;
  840.         reservedH1:                LONGINT;
  841.         reservedH2:                LONGINT;
  842.         ioCompletion:            IPMIOCompletionUPP;
  843.         ioResult:                OSErr;
  844.         saveA5:                    LONGINT;
  845.         reqCode:                INTEGER;
  846.         msgRef:                    IPMMsgRef;
  847.         msgID:                    IPMMsgID;
  848.         msgTitle:                ^RString;
  849.         deliveryNotification:    IPMNotificationType;
  850.         priority:                IPMPriority;
  851.         cancel:                    BOOLEAN;
  852.         padByte:                SInt8; (* Byte *)
  853.         reserved:                LONGINT;
  854.         signature:                SIGSignaturePtr;
  855.         signatureSize:            Size;
  856.         signatureContext:        SIGContextPtr;
  857.         { family this msg belongs (e.g. mail) use kIPMFamilyUnspecified by default }
  858.         family:                    OSType;
  859.     END;
  860.  
  861.     IPMAddRecipientPB = RECORD
  862.         qLink:                    Ptr;
  863.         reservedH1:                LONGINT;
  864.         reservedH2:                LONGINT;
  865.         ioCompletion:            IPMIOCompletionUPP;
  866.         ioResult:                OSErr;
  867.         saveA5:                    LONGINT;
  868.         reqCode:                INTEGER;
  869.         msgRef:                    IPMMsgRef;
  870.         recipient:                ^OCERecipient;
  871.         reserved:                LONGINT;
  872.     END;
  873.  
  874.     IPMAddReplyQueuePB = RECORD
  875.         qLink:                    Ptr;
  876.         reservedH1:                LONGINT;
  877.         reservedH2:                LONGINT;
  878.         ioCompletion:            IPMIOCompletionUPP;
  879.         ioResult:                OSErr;
  880.         saveA5:                    LONGINT;
  881.         reqCode:                INTEGER;
  882.         msgRef:                    IPMMsgRef;
  883.         filler:                    LONGINT;
  884.         replyQueue:                ^OCERecipient;
  885.     END;
  886.  
  887.     IPMNewBlockPB = RECORD
  888.         qLink:                    Ptr;
  889.         reservedH1:                LONGINT;
  890.         reservedH2:                LONGINT;
  891.         ioCompletion:            IPMIOCompletionUPP;
  892.         ioResult:                OSErr;
  893.         saveA5:                    LONGINT;
  894.         reqCode:                INTEGER;
  895.         msgRef:                    IPMMsgRef;
  896.         blockType:                IPMBlockType;
  897.         filler:                    ARRAY [0..4] OF INTEGER;
  898.         refCon:                    LONGINT;
  899.         filler2:                ARRAY [0..2] OF INTEGER;
  900.         startingOffset:            LONGINT;
  901.     END;
  902.  
  903.     IPMWriteMsgPB = RECORD
  904.         qLink:                    Ptr;
  905.         reservedH1:                LONGINT;
  906.         reservedH2:                LONGINT;
  907.         ioCompletion:            IPMIOCompletionUPP;
  908.         ioResult:                OSErr;
  909.         saveA5:                    LONGINT;
  910.         reqCode:                INTEGER;
  911.         msgRef:                    IPMMsgRef;
  912.         mode:                    IPMAccessMode;
  913.         offset:                    LONGINT;
  914.         count:                    LONGINT;
  915.         buffer:                    Ptr;
  916.         actualCount:            LONGINT;
  917.         currentBlock:            BOOLEAN;
  918.         filler1:                BOOLEAN;
  919.     END;
  920.  
  921.     IPMParamBlock = RECORD
  922.         CASE INTEGER OF
  923.         0: (
  924.             qLink:                        Ptr;
  925.             reservedH1:                    LONGINT;
  926.             reservedH2:                    LONGINT;
  927.             ioCompletion:                IPMIOCompletionUPP;
  928.             ioResult:                    OSErr;
  929.             saveA5:                        LONGINT;
  930.             reqCode:                    INTEGER;
  931.            );
  932.         1: (
  933.             openContextPB:                IPMOpenContextPB;
  934.            );
  935.         2: (
  936.             closeContextPB:                IPMCloseContextPB;
  937.            );
  938.         3: (
  939.             createQueuePB:                IPMCreateQueuePB;
  940.            );
  941.         4: (
  942.             deleteQueuePB:                IPMDeleteQueuePB;
  943.            );
  944.         5: (
  945.             openQueuePB:                IPMOpenQueuePB;
  946.            );
  947.         6: (
  948.             closeQueuePB:                IPMCloseQueuePB;
  949.            );
  950.         7: (
  951.             enumerateQueuePB:            IPMEnumerateQueuePB;
  952.            );
  953.         8: (
  954.             changeQueueFilterPB:        IPMChangeQueueFilterPB;
  955.            );
  956.         9: (
  957.             deleteMsgRangePB:            IPMDeleteMsgRangePB;
  958.            );
  959.         10: (
  960.             openMsgPB:                    IPMOpenMsgPB;
  961.            );
  962.         11: (
  963.             openHFSMsgPB:                IPMOpenHFSMsgPB;
  964.            );
  965.         12: (
  966.             openBlockAsMsgPB:            IPMOpenBlockAsMsgPB;
  967.            );
  968.         13: (
  969.             closeMsgPB:                    IPMCloseMsgPB;
  970.            );
  971.         14: (
  972.             getMsgInfoPB:                IPMGetMsgInfoPB;
  973.            );
  974.         15: (
  975.             readHeaderPB:                IPMReadHeaderPB;
  976.            );
  977.         16: (
  978.             readRecipientPB:            IPMReadRecipientPB;
  979.            );
  980.         17: (
  981.             readReplyQueuePB:            IPMReadReplyQueuePB;
  982.            );
  983.         18: (
  984.             getBlkIndexPB:                IPMGetBlkIndexPB;
  985.            );
  986.         19: (
  987.             readMsgPB:                    IPMReadMsgPB;
  988.            );
  989.         20: (
  990.             verifySignaturePB:            IPMVerifySignaturePB;
  991.            );
  992.         21: (
  993.             newMsgPB:                    IPMNewMsgPB;
  994.            );
  995.         22: (
  996.             newHFSMsgPB:                IPMNewHFSMsgPB;
  997.            );
  998.         23: (
  999.             nestMsgPB:                    IPMNestMsgPB;
  1000.            );
  1001.         24: (
  1002.             newNestedMsgBlockPB:        IPMNewNestedMsgBlockPB;
  1003.            );
  1004.         25: (
  1005.             endMsgPB:                    IPMEndMsgPB;
  1006.            );
  1007.         26: (
  1008.             addRecipientPB:                IPMAddRecipientPB;
  1009.            );
  1010.         27: (
  1011.             addReplyQueuePB:            IPMAddReplyQueuePB;
  1012.            );
  1013.         28: (
  1014.             newBlockPB:                    IPMNewBlockPB;
  1015.            );
  1016.         29: (
  1017.             writeMsgPB:                    IPMWriteMsgPB;
  1018.            );
  1019.     END;
  1020.  
  1021. CONST
  1022.     uppIPMIOCompletionProcInfo = $000000C0; { PROCEDURE (4 byte param); }
  1023.  
  1024. PROCEDURE CallIPMIOCompletionProc(paramBlock: IPMParamBlockPtr; userRoutine: IPMIOCompletionUPP);
  1025.     {$IFC NOT GENERATINGCFM}
  1026.     INLINE $205F, $4E90;
  1027.     {$ENDC}
  1028.  
  1029. FUNCTION NewIPMIOCompletionProc(userRoutine: IPMIOCompletionProcPtr): IPMIOCompletionUPP;
  1030.     {$IFC NOT GENERATINGCFM }
  1031.     INLINE $2E9F;
  1032.     {$ENDC}
  1033.  
  1034. FUNCTION IPMOpenContext(paramBlock: IPMParamBlockPtr; async: BOOLEAN): OSErr;
  1035.     {$IFC NOT GENERATINGCFM}
  1036.     INLINE $3F3C, $400, $AA5E;
  1037.     {$ENDC}
  1038. FUNCTION IPMCloseContext(paramBlock: IPMParamBlockPtr; async: BOOLEAN): OSErr;
  1039.     {$IFC NOT GENERATINGCFM}
  1040.     INLINE $3F3C, $401, $AA5E;
  1041.     {$ENDC}
  1042. FUNCTION IPMNewMsg(paramBlock: IPMParamBlockPtr; async: BOOLEAN): OSErr;
  1043.     {$IFC NOT GENERATINGCFM}
  1044.     INLINE $3F3C, $402, $AA5E;
  1045.     {$ENDC}
  1046. FUNCTION IPMNewBlock(paramBlock: IPMParamBlockPtr; async: BOOLEAN): OSErr;
  1047.     {$IFC NOT GENERATINGCFM}
  1048.     INLINE $3F3C, $404, $AA5E;
  1049.     {$ENDC}
  1050. FUNCTION IPMNewNestedMsgBlock(paramBlock: IPMParamBlockPtr; async: BOOLEAN): OSErr;
  1051.     {$IFC NOT GENERATINGCFM}
  1052.     INLINE $3F3C, $405, $AA5E;
  1053.     {$ENDC}
  1054. FUNCTION IPMNestMsg(paramBlock: IPMParamBlockPtr; async: BOOLEAN): OSErr;
  1055.     {$IFC NOT GENERATINGCFM}
  1056.     INLINE $3F3C, $406, $AA5E;
  1057.     {$ENDC}
  1058. FUNCTION IPMWriteMsg(paramBlock: IPMParamBlockPtr; async: BOOLEAN): OSErr;
  1059.     {$IFC NOT GENERATINGCFM}
  1060.     INLINE $3F3C, $407, $AA5E;
  1061.     {$ENDC}
  1062. FUNCTION IPMEndMsg(paramBlock: IPMParamBlockPtr; async: BOOLEAN): OSErr;
  1063.     {$IFC NOT GENERATINGCFM}
  1064.     INLINE $3F3C, $408, $AA5E;
  1065.     {$ENDC}
  1066. FUNCTION IPMOpenQueue(paramBlock: IPMParamBlockPtr; async: BOOLEAN): OSErr;
  1067.     {$IFC NOT GENERATINGCFM}
  1068.     INLINE $3F3C, $409, $AA5E;
  1069.     {$ENDC}
  1070. FUNCTION IPMCloseQueue(paramBlock: IPMParamBlockPtr; async: BOOLEAN): OSErr;
  1071.     {$IFC NOT GENERATINGCFM}
  1072.     INLINE $3F3C, $40A, $AA5E;
  1073.     {$ENDC}
  1074. { Always synchronous }
  1075. FUNCTION IPMVerifySignature(paramBlock: IPMParamBlockPtr): OSErr;
  1076.     {$IFC NOT GENERATINGCFM}
  1077.     INLINE $7000, $1f00, $3F3C, $422, $AA5E;
  1078.     {$ENDC}
  1079. FUNCTION IPMOpenMsg(paramBlock: IPMParamBlockPtr; async: BOOLEAN): OSErr;
  1080.     {$IFC NOT GENERATINGCFM}
  1081.     INLINE $3F3C, $40B, $AA5E;
  1082.     {$ENDC}
  1083. FUNCTION IPMCloseMsg(paramBlock: IPMParamBlockPtr; async: BOOLEAN): OSErr;
  1084.     {$IFC NOT GENERATINGCFM}
  1085.     INLINE $3F3C, $40C, $AA5E;
  1086.     {$ENDC}
  1087. FUNCTION IPMReadMsg(paramBlock: IPMParamBlockPtr; async: BOOLEAN): OSErr;
  1088.     {$IFC NOT GENERATINGCFM}
  1089.     INLINE $3F3C, $40D, $AA5E;
  1090.     {$ENDC}
  1091. FUNCTION IPMReadHeader(paramBlock: IPMParamBlockPtr; async: BOOLEAN): OSErr;
  1092.     {$IFC NOT GENERATINGCFM}
  1093.     INLINE $3F3C, $40E, $AA5E;
  1094.     {$ENDC}
  1095. FUNCTION IPMOpenBlockAsMsg(paramBlock: IPMParamBlockPtr; async: BOOLEAN): OSErr;
  1096.     {$IFC NOT GENERATINGCFM}
  1097.     INLINE $3F3C, $40F, $AA5E;
  1098.     {$ENDC}
  1099. FUNCTION IPMNewHFSMsg(paramBlock: IPMParamBlockPtr; async: BOOLEAN): OSErr;
  1100.     {$IFC NOT GENERATINGCFM}
  1101.     INLINE $3F3C, $41E, $AA5E;
  1102.     {$ENDC}
  1103. FUNCTION IPMReadRecipient(paramBlock: IPMParamBlockPtr; async: BOOLEAN): OSErr;
  1104.     {$IFC NOT GENERATINGCFM}
  1105.     INLINE $3F3C, $410, $AA5E;
  1106.     {$ENDC}
  1107. FUNCTION IPMReadReplyQueue(paramBlock: IPMParamBlockPtr; async: BOOLEAN): OSErr;
  1108.     {$IFC NOT GENERATINGCFM}
  1109.     INLINE $3F3C, $421, $AA5E;
  1110.     {$ENDC}
  1111. FUNCTION IPMCreateQueue(paramBlock: IPMParamBlockPtr; async: BOOLEAN): OSErr;
  1112.     {$IFC NOT GENERATINGCFM}
  1113.     INLINE $3F3C, $411, $AA5E;
  1114.     {$ENDC}
  1115. FUNCTION IPMDeleteQueue(paramBlock: IPMParamBlockPtr; async: BOOLEAN): OSErr;
  1116.     {$IFC NOT GENERATINGCFM}
  1117.     INLINE $3F3C, $412, $AA5E;
  1118.     {$ENDC}
  1119. FUNCTION IPMEnumerateQueue(paramBlock: IPMParamBlockPtr; async: BOOLEAN): OSErr;
  1120.     {$IFC NOT GENERATINGCFM}
  1121.     INLINE $3F3C, $413, $AA5E;
  1122.     {$ENDC}
  1123. FUNCTION IPMChangeQueueFilter(paramBlock: IPMParamBlockPtr; async: BOOLEAN): OSErr;
  1124.     {$IFC NOT GENERATINGCFM}
  1125.     INLINE $3F3C, $414, $AA5E;
  1126.     {$ENDC}
  1127. FUNCTION IPMDeleteMsgRange(paramBlock: IPMParamBlockPtr; async: BOOLEAN): OSErr;
  1128.     {$IFC NOT GENERATINGCFM}
  1129.     INLINE $3F3C, $415, $AA5E;
  1130.     {$ENDC}
  1131. FUNCTION IPMAddRecipient(paramBlock: IPMParamBlockPtr; async: BOOLEAN): OSErr;
  1132.     {$IFC NOT GENERATINGCFM}
  1133.     INLINE $3F3C, $403, $AA5E;
  1134.     {$ENDC}
  1135. FUNCTION IPMAddReplyQueue(paramBlock: IPMParamBlockPtr; async: BOOLEAN): OSErr;
  1136.     {$IFC NOT GENERATINGCFM}
  1137.     INLINE $3F3C, $41D, $AA5E;
  1138.     {$ENDC}
  1139. FUNCTION IPMOpenHFSMsg(paramBlock: IPMParamBlockPtr; async: BOOLEAN): OSErr;
  1140.     {$IFC NOT GENERATINGCFM}
  1141.     INLINE $3F3C, $417, $AA5E;
  1142.     {$ENDC}
  1143. FUNCTION IPMGetBlkIndex(paramBlock: IPMParamBlockPtr; async: BOOLEAN): OSErr;
  1144.     {$IFC NOT GENERATINGCFM}
  1145.     INLINE $3F3C, $418, $AA5E;
  1146.     {$ENDC}
  1147. FUNCTION IPMGetMsgInfo(paramBlock: IPMParamBlockPtr; async: BOOLEAN): OSErr;
  1148.     {$IFC NOT GENERATINGCFM}
  1149.     INLINE $3F3C, $419, $AA5E;
  1150.     {$ENDC}
  1151.  
  1152. {$ALIGN RESET}
  1153. {$POP}
  1154.  
  1155. {$SETC UsingIncludes := OCEMessagingIncludes}
  1156.  
  1157. {$ENDC} {__OCEMESSAGING__}
  1158.  
  1159. {$IFC NOT UsingIncludes}
  1160.  END.
  1161. {$ENDC}
  1162.